/*
  EJERCICIO:
    - En este ejercicio introducimos nuevos elementos sintacticos, tomate un
    tiempo para leer el codigo y los comentarios antes de continuar.
      Importante: Pregunta todos los detalles que no sean claros, es importante
      entender que hace este programa simple para poder continuar
      con el ejercicio.
	  
	... ahora que ya leiste el codigo:

    - Re-escribe el ciclo de la funcion cantidadDeEspaciosEn(texto) usando :
            while (CONDICION) {}

       Puedes usar la funcion cantidadDeConsonantesEn(texto) como ejemplo.

    - Re-escribe  cantidadDeConsonantesEn(texto) para usar: for
    
    - Implementa la funcion cantidadDeVocales
*/

package cursopoo.ejercicios

import static cursopoo.herramientas.EjerciciosIniciales.*

/*
  cursopoo.herramientas es un paquete, mas adelante veremos que es
  EjerciciosIniciales y por que lo escribimos comenzando con mayuculas, por
  ahora alcanza con saber que estamos diciendo que queremos usar las rutinas
  de algo llamado: cursopoo.herramientas.EjerciciosIniciales.

  Dichas rutinas son para programar en un estilo "estructurado", ya que aun no
  hemos visto conceptos de POO.

  Muchos lenguajes de programacion permiten organizar el codigo en "paquetes"
  o "espacios de nombres" (namespaces), esto es util para evitar colisiones de
  nombres. Por ejemplo en un mismo programa podriamos usar:
  cursopoo.Rutinas y otro.paquete.Rutinas, para distinguir que Rutinas estamos
  usando nos podemos referir a ellas con su nombre calificado (qualified name) es
  decir poniendo como prefijo el nombre del paquete.

  "import" se usa para indicarle al compilador que queremos usar determinados
  paquetes, de esa forma no es necesario agregar el prefijo del paquete cada
  vez que querramos algo de este. Por ejemplo si no hubiesemos escrito la linea
  anterior, en lugar de escribir:
      longitud(texto)
  tendriamos que escribir:
      cursopoo.herramientas.EjerciciosIniciales.longitud(texto)
 */

println 'Ingresa un texto y presiona ENTER para terminar:'

def textoLeido = leerLineaDesdeLaConsola()

println 'Caracteres    : ' + longitud(textoLeido)
println 'Espacios       : ' + cantidadDeEspaciosEn(textoLeido)
println 'Vocales        : ' + cantidadDeVocalesEn(textoLeido)
println 'Consonantes : ' + cantidadDeConsonantesEn(textoLeido)

def cantidadDeEspaciosEn(texto) {
    def resultado = 0

    // los ciclos se pueden escribir como en C:
    // for (INICIO; CONDICION; PASO) {  }
    // PARAHACER Re-escribir usando while
    for (def i = 0; i < longitud(texto); i++) {
        // al igual que en C, i++ es lo mismo que: i = i + 1
        if (texto[i] == " ") {
            resultado = resultado + 1
        }
    }

    return resultado
}

def cantidadDeConsonantesEn(texto) {
    def resultado = 0
    def i = 0

    // PARAHACER Re-escribir usando for
    while (i < longitud(texto)) {
        if (esConsonante(texto[i])) {
            resultado++
        }
        i++
    }

    return resultado
}

def esConsonante(caracter) {
    def c = aMinuscula(caracter);

    // las barras || representan como en C el operador logico OR, hay muchas otras
    // formas mas cortas de escribir esto (se te ocurren algunas?)

    def resultado = c == 'b' || c == 'c' || c == 'd' || c == 'f' || c == 'g' || c == 'h' || c == 'j' ||
            c == 'k' || c == 'l' || c == 'm' || c == 'n' || c == 'p' || c == 'q' || c == 'r' || c == 's' ||
            c == 't' || c == 'v' || c == 'w' || c == 'x' || c == 'y' || c == 'z'

    // las lineas de codigo se pueden extender a mas de una linea, es importante
    // que || este al final asi el interprete sabe que la linea puede continuar

    return resultado
}

def cantidadDeVocalesEn(texto) {
    // PARAHACER Implementar esta rutina
    // CAMBIAR
    return longitud(texto) - cantidadDeEspaciosEn(texto) - cantidadDeConsonantesEn(texto)
    // POR return 0
}